home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xarchie-2.0.9 / FWF / MultiList / MultiList.c < prev    next >
C/C++ Source or Header  |  1995-06-18  |  55KB  |  1,761 lines
  1. /****************************************************************************
  2.  
  3.     MultiList.c
  4.  
  5.     This file contains the implementation of the Picasso List
  6.     widget.  Its functionality is intended to be similar to
  7.     The Athena List widget, with some extra features added.
  8.  
  9.     This code is loosely based on the Athena List source which
  10.     is why the MIT copyright notice appears below.
  11.  
  12.     The code was changed substantially in V3.4 to change the
  13.     action/callback interface which was unnecessarily ugly.  Code
  14.     using some features of the old interface may need to be changed.
  15.     Hope the changes don't make people's lives too miserable.
  16.  
  17.  ****************************************************************************/
  18.  
  19. /*
  20.  * Author:
  21.  *     Brian Totty
  22.  *     Department of Computer Science
  23.  *     University Of Illinois at Urbana-Champaign
  24.  *    1304 West Springfield Avenue
  25.  *     Urbana, IL 61801
  26.  * 
  27.  *     totty@cs.uiuc.edu
  28.  *     
  29.  */ 
  30.  
  31. /*
  32.  * Copyright 1989 Massachusetts Institute of Technology
  33.  *
  34.  * Permission to use, copy, modify, distribute, and sell this software and its
  35.  * documentation for any purpose is hereby granted without fee, provided that
  36.  * the above copyright notice appear in all copies and that both that
  37.  * copyright notice and this permission notice appear in supporting
  38.  * documentation, and that the name of M.I.T. not be used in advertising or
  39.  * publicity pertaining to distribution of the software without specific,
  40.  * written prior permission.  M.I.T. makes no representations about the
  41.  * suitability of this software for any purpose.  It is provided "as is"
  42.  * without express or implied warranty.
  43.  *
  44.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  45.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  46.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  47.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  48.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
  49.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  50.  *
  51.  * Original Athena Author:  Chris D. Peterson, MIT X Consortium
  52.  */
  53.  
  54. #include <stdio.h>
  55. #include <ctype.h>
  56.  
  57. #include <X11/IntrinsicP.h>
  58. #include <X11/StringDefs.h>
  59.  
  60. #include <MultiListP.h>
  61.  
  62. /*===========================================================================*
  63.  
  64.           D E C L A R A T I O N S    A N D    D E F I N I T I O N S
  65.  
  66.  *===========================================================================*/
  67.  
  68. Pixmap XmuCreateStippledPixmap();
  69. extern void XawInitializeWidgetSet();
  70.  
  71. #define    SUPERCLASS    &(simpleClassRec)
  72.  
  73. #define    FontAscent(f)    ((f)->max_bounds.ascent)
  74. #define    FontDescent(f)    ((f)->max_bounds.descent)
  75. #define    FontH(f)    (FontAscent(f) + FontDescent(f) + 2)
  76. #define    FontW(f,s)    (XTextWidth(f,s,strlen(s)) + 1)
  77. #define    FontMaxCharW(f)    ((f)->max_bounds.rbearing-(f)->min_bounds.lbearing+1)
  78.  
  79. #ifndef abs
  80. #define abs(a)            ((a) < 0 ? -(a) : (a))
  81. #endif
  82.  
  83. #define max(a,b)        ((a) > (b) ? (a) : (b))
  84. #define min(a,b)        ((a) < (b) ? (a) : (b))
  85. #define XtStrlen(s)        ((s) ? strlen(s) : 0)
  86.  
  87. #define    TypeAlloc(t,n)        (t *)malloc(sizeof(t) * n)
  88. #define    StrCopy(s)        strcpy(TypeAlloc(char,strlen(s)+1),s)
  89. #define    StrCopyRetLength(s,lp)    strcpy(TypeAlloc(char,(*lp=(strlen(s)+1))),s)
  90.  
  91. #define CoreFieldOffset(f)    XtOffset(Widget,core.f)
  92. #define    SimpleFieldOffset(f)    XtOffset(XfwfMultiListWidget,simple.f)
  93. #define MultiListFieldOffset(f)    XtOffset(XfwfMultiListWidget,multiList.f)
  94.  
  95. /*===========================================================================*
  96.  
  97.         I N T E R N A L    P R O C E D U R E    D E C L A R A T I O N S
  98.  
  99.  *===========================================================================*/
  100.  
  101. #if (!NeedFunctionPrototypes)
  102.  
  103. static void            Initialize();
  104. static void            Redisplay();
  105. static XtGeometryResult        PreferredGeometry();
  106. static void            Resize();
  107. static Boolean            SetValues();
  108.  
  109. static void            DestroyOldData();
  110. static void            InitializeNewData();
  111. static void            CreateNewGCs();
  112.  
  113. static void            RecalcCoords();
  114. static void            NegotiateSizeChange();
  115. static Boolean            Layout();
  116.  
  117. static void            RedrawAll();
  118. static void            RedrawItem();
  119. static void            RedrawRowColumn();
  120.  
  121. static void            PixelToRowColumn();
  122. static void            RowColumnToPixels();
  123. static Boolean            RowColumnToItem();
  124. static Boolean            ItemToRowColumn();
  125.  
  126. static void            Select();
  127. static void            Unselect();
  128. static void            Toggle();
  129. static void            Extend();
  130. static void            Notify();
  131.  
  132. #else
  133.  
  134. static void        Initialize(Widget request, Widget new);
  135. static void         Redisplay(XfwfMultiListWidget mlw,
  136.                 XEvent *event, Region rectangle_union);
  137. static XtGeometryResult PreferredGeometry(XfwfMultiListWidget mlw,
  138.                 XtWidgetGeometry *parent_idea,
  139.                 XtWidgetGeometry *our_idea);
  140. static void        Resize(XfwfMultiListWidget mlw);
  141. static Boolean        SetValues(XfwfMultiListWidget cpl,
  142.                 XfwfMultiListWidget rpl,
  143.             XfwfMultiListWidget npl);
  144. static void        DestroyOldData(XfwfMultiListWidget mlw);
  145. static void        InitializeNewData(XfwfMultiListWidget mlw);
  146. static void        CreateNewGCs(XfwfMultiListWidget mlw);
  147. static void        RecalcCoords(XfwfMultiListWidget mlw,
  148.                 Boolean width_changeable,
  149.                 Boolean height_changeable);
  150. static void        NegotiateSizeChange(XfwfMultiListWidget mlw,
  151.                 Dimension width, Dimension height);
  152. static Boolean        Layout(XfwfMultiListWidget mlw,
  153.                 Boolean w_changeable, Boolean h_changeable,
  154.                 Dimension *w_ptr, Dimension *h_ptr);
  155. static void        RedrawAll(XfwfMultiListWidget mlw);
  156. static void        RedrawItem(XfwfMultiListWidget mlw, int item_index);
  157. static void        RedrawRowColumn(XfwfMultiListWidget mlw,
  158.                 int row, int column);
  159. static void        PixelToRowColumn(XfwfMultiListWidget mlw,
  160.                 int x, int y, int *row_ptr, int *column_ptr);
  161. static void        RowColumnToPixels(XfwfMultiListWidget mlw,
  162.                 int row, int col, int *x_ptr, int *y_ptr,
  163.                 int *w_ptr, int *h_ptr);
  164. static Boolean        RowColumnToItem(XfwfMultiListWidget mlw,
  165.                 int row, int column, int *item_ptr);
  166. static Boolean        ItemToRowColumn(XfwfMultiListWidget mlw,
  167.                 int item_index, int *row_ptr, int *column_ptr);
  168. static void        Select(XfwfMultiListWidget mlw, XEvent *event,
  169.                 String *params, Cardinal *num_params);
  170. static void        Unselect(XfwfMultiListWidget mlw, XEvent *event,
  171.                 String *params, Cardinal *num_params);
  172. static void        Toggle(XfwfMultiListWidget mlw, XEvent *event,
  173.                 String *params, Cardinal *num_params);
  174. static void        Extend(XfwfMultiListWidget mlw, XEvent *event,
  175.                 String *params, Cardinal *num_params);
  176. static void        Notify(XfwfMultiListWidget mlw, XEvent *event,
  177.                 String *params, Cardinal *num_params);
  178. #endif
  179.  
  180. /*===========================================================================*
  181.  
  182.               R E S O U R C E    I N I T I A L I Z A T I O N
  183.  
  184.  *===========================================================================*/
  185.  
  186. static XtResource resources[] =
  187. {
  188.     {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
  189.         CoreFieldOffset(width), XtRString, "0"},
  190.     {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
  191.         CoreFieldOffset(height), XtRString, "0"},
  192.     {XtNbackground, XtCBackground, XtRPixel, sizeof(Pixel),
  193.         CoreFieldOffset(background_pixel),XtRString,"XtDefaultBackground"},
  194.  
  195.     {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
  196.         SimpleFieldOffset(cursor), XtRString, "left_ptr"},
  197.  
  198.     {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  199.         MultiListFieldOffset(foreground), XtRString,"XtDefaultForeground"},
  200.     {XtNhighlightForeground, XtCHForeground, XtRPixel, sizeof(Pixel),
  201.         MultiListFieldOffset(highlight_fg), XtRString, "XtDefaultBackground"},
  202.     {XtNhighlightBackground, XtCHBackground, XtRPixel, sizeof(Pixel),
  203.         MultiListFieldOffset(highlight_bg), XtRString, "XtDefaultForeground"},
  204.     {XtNcolumnSpacing, XtCSpacing, XtRDimension, sizeof(Dimension),
  205.         MultiListFieldOffset(column_space), XtRImmediate, (caddr_t)8},
  206.     {XtNrowSpacing, XtCSpacing, XtRDimension, sizeof(Dimension),
  207.         MultiListFieldOffset(row_space), XtRImmediate, (caddr_t)0},
  208.     {XtNdefaultColumns, XtCColumns, XtRInt,  sizeof(int),
  209.         MultiListFieldOffset(default_cols), XtRImmediate, (caddr_t)1},
  210.     {XtNforceColumns, XtCColumns, XtRBoolean, sizeof(Boolean),
  211.         MultiListFieldOffset(force_cols), XtRString, (caddr_t) "False"},
  212.     {XtNpasteBuffer, XtCBoolean, XtRBoolean, sizeof(Boolean),
  213.         MultiListFieldOffset(paste), XtRString, (caddr_t) "False"},
  214.     {XtNverticalList, XtCBoolean, XtRBoolean,  sizeof(Boolean),
  215.         MultiListFieldOffset(row_major), XtRString, (caddr_t) "False"},
  216.     {XtNlongest, XtCLongest, XtRInt,  sizeof(int),
  217.         MultiListFieldOffset(longest), XtRImmediate, (caddr_t)0},
  218.     {XtNnumberStrings, XtCNumberStrings, XtRInt,  sizeof(int),
  219.         MultiListFieldOffset(nitems), XtRImmediate, (caddr_t)0},
  220.     {XtNfont,  XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  221.         MultiListFieldOffset(font),XtRString, "XtDefaultFont"},
  222.     {XtNlist, XtCList, XtRPointer, sizeof(char **),
  223.         MultiListFieldOffset(list), XtRString, NULL},
  224.     {XtNsensitiveArray, XtCList, XtRPointer, sizeof(Boolean *),
  225.         MultiListFieldOffset(sensitive_array), XtRString, NULL},
  226.     {XtNcallback, XtCCallback, XtRCallback, sizeof(caddr_t),
  227.         MultiListFieldOffset(callback), XtRCallback, NULL},
  228.     {XtNmaxSelectable, XtCValue, XtRInt, sizeof(int),
  229.         MultiListFieldOffset(max_selectable), XtRImmediate, (caddr_t) 1},
  230.  
  231.     {XtNshadeSurplus, XtCBoolean, XtRBoolean, sizeof(Boolean),
  232.         MultiListFieldOffset(shade_surplus), XtRString, "True"},
  233.  
  234.     {XtNcolumnWidth, XtCValue, XtRDimension, sizeof(Dimension),
  235.         MultiListFieldOffset(col_width), XtRImmediate, (caddr_t)0},
  236.     {XtNrowHeight, XtCValue, XtRDimension, sizeof(Dimension),
  237.         MultiListFieldOffset(row_height), XtRImmediate, (caddr_t)0},
  238. };
  239.  
  240. /*===========================================================================*
  241.  
  242.         A C T I O N    A N D    T R A N S L A T I O N    T A B L E S
  243.  
  244.  *===========================================================================*/
  245.  
  246.  
  247. static char defaultTranslations[] =
  248. "    Shift <Btn1Down>:            Toggle()\n\
  249.     Ctrl <Btn1Down>:            Unselect()\n\
  250.     <Btn1Down>:                Select()\n\
  251.     Button1 <Btn1Motion>:            Extend()\n\
  252.     <Btn1Up>:                Notify()";
  253.  
  254. static XtActionsRec actions[] =
  255. {
  256.     {"Select",                (XtActionProc)Select},
  257.     {"Unselect",                (XtActionProc)Unselect},
  258.     {"Toggle",                (XtActionProc)Toggle},
  259.     {"Extend",                (XtActionProc)Extend},
  260.     {"Notify",                (XtActionProc)Notify},
  261.     {NULL,                    (XtActionProc)NULL}
  262. };
  263.  
  264. /*===========================================================================*
  265.  
  266.                     C L A S S    A L L O C A T I O N
  267.  
  268.  *===========================================================================*/
  269.  
  270. XfwfMultiListClassRec xfwfMultiListClassRec =
  271. {
  272.     {
  273.         /* superclass        */    (WidgetClass)SUPERCLASS,
  274.         /* class_name        */    "XfwfMultiList",
  275.         /* widget_size        */    sizeof(XfwfMultiListRec),
  276.         /* class_initialize    */    NULL,
  277.         /* class_part_initialize*/    NULL,
  278.         /* class_inited        */    FALSE,
  279.         /* initialize        */    (XtInitProc)Initialize,
  280.         /* initialize_hook    */    NULL,
  281.         /* realize        */    XtInheritRealize,
  282.         /* actions        */    actions,
  283.         /* num_actions        */    XtNumber(actions),
  284.         /* resources        */    resources,
  285.         /* resource_count    */    XtNumber(resources),
  286.         /* xrm_class        */    NULLQUARK,
  287.         /* compress_motion    */    TRUE,
  288.         /* compress_exposure    */    FALSE,
  289.         /* compress_enterleave    */    TRUE,
  290.         /* visible_interest    */    FALSE,
  291.         /* destroy        */    NULL,
  292.         /* resize        */    (XtWidgetProc)Resize,
  293.         /* expose        */    (XtExposeProc)Redisplay,
  294.         /* set_values        */    (XtSetValuesFunc)SetValues,
  295.         /* set_values_hook    */    NULL,
  296.         /* set_values_almost    */    XtInheritSetValuesAlmost,
  297.         /* get_values_hook    */    NULL,
  298.         /* accept_focus        */    NULL,
  299.         /* version        */    XtVersion,
  300.         /* callback_private    */    NULL,
  301.         /* tm_table        */    defaultTranslations,
  302.         /* query_geometry       */    (XtGeometryHandler)
  303.                             PreferredGeometry,
  304.         /* display_accelerator  */    XtInheritDisplayAccelerator,
  305.         /* extension            */    NULL
  306.     }, /* Core Part */
  307.     {
  308.         /* change_sensitive     */    XtInheritChangeSensitive
  309.     }
  310. };
  311.  
  312. WidgetClass xfwfMultiListWidgetClass = (WidgetClass)&xfwfMultiListClassRec;
  313.  
  314. /*===========================================================================*
  315.  
  316.                        T O O L K I T    M E T H O D S
  317.  
  318.  *===========================================================================*/
  319.  
  320. /*---------------------------------------------------------------------------*
  321.  
  322.     Initialize()
  323.  
  324.     This procedure is called by the X toolkit to initialize
  325.     the widget instance.  The hook to this routine is in the
  326.     initialize part of the core part of the class.
  327.  
  328.  *---------------------------------------------------------------------------*/
  329.  
  330. /* ARGSUSED */
  331. static void Initialize(request,new)
  332. Widget request,new;
  333. {
  334.     XfwfMultiListWidget mlw;
  335.  
  336.     mlw = (XfwfMultiListWidget)new;
  337.     CreateNewGCs(mlw);
  338.     InitializeNewData(mlw);
  339.     RecalcCoords(mlw,(MultiListWidth(mlw) == 0),
  340.              (MultiListHeight(mlw) == 0));
  341. } /* Initialize */
  342.  
  343.  
  344. /*---------------------------------------------------------------------------*
  345.  
  346.     Redisplay(mlw,event,rectangle_union)
  347.  
  348.     This routine redraws the MultiList widget <mlw> based on the exposure
  349.     region requested in <event>.
  350.  
  351.  *---------------------------------------------------------------------------*/
  352.  
  353. /* ARGSUSED */
  354. static void Redisplay(mlw,event,rectangle_union)
  355. XfwfMultiListWidget mlw;
  356. XEvent *event;
  357. Region rectangle_union;
  358. {
  359.     GC shade_gc;
  360.     int i,x1,y1,w,h,x2,y2,row,col,ul_row,ul_col,lr_row,lr_col;
  361.  
  362.     if (MultiListShadeSurplus(mlw))
  363.         shade_gc = MultiListGrayGC(mlw);
  364.         else
  365.         shade_gc = MultiListEraseGC(mlw);
  366.     if (event == NULL)
  367.     {
  368.         XFillRectangle(XtDisplay(mlw),XtWindow(mlw),shade_gc,0,0,
  369.                    MultiListWidth(mlw),MultiListHeight(mlw));
  370.         for (i = 0; i < MultiListNumItems(mlw); i++) RedrawItem(mlw,i);
  371.     }
  372.         else
  373.     {
  374.         x1 = event->xexpose.x;
  375.         y1 = event->xexpose.y;
  376.         w = event->xexpose.width;
  377.         h = event->xexpose.height;
  378.         x2 = x1 + w;
  379.         y2 = y1 + h;
  380.         XFillRectangle(XtDisplay(mlw),XtWindow(mlw),
  381.                    shade_gc,x1,y1,w,h);
  382.         PixelToRowColumn(mlw,x1,y1,&ul_row,&ul_col);
  383.         PixelToRowColumn(mlw,x2,y2,&lr_row,&lr_col);
  384.         lr_row = min(lr_row,MultiListNumRows(mlw) - 1);
  385.         lr_col = min(lr_col,MultiListNumCols(mlw) - 1);
  386.         for (col = ul_col; col <= lr_col; col++)
  387.         {
  388.             for (row = ul_row; row <= lr_row; row++)
  389.             {
  390.                 RedrawRowColumn(mlw,row,col);
  391.             }
  392.         }
  393.     }
  394. } /* End Redisplay */
  395.  
  396.  
  397. /*---------------------------------------------------------------------------*
  398.  
  399.     PreferredGeometry(mlw,parent_idea,our_idea)
  400.  
  401.     This routine is called by the parent to tell us about the
  402.     parent's idea of our width and/or height.  We then suggest
  403.     our preference through <our_idea> and return the information
  404.     to the parent.
  405.  
  406.  *---------------------------------------------------------------------------*/
  407.  
  408. static XtGeometryResult PreferredGeometry(mlw,parent_idea,our_idea)
  409. XfwfMultiListWidget mlw;
  410. XtWidgetGeometry *parent_idea,*our_idea;
  411. {
  412.     Dimension nw,nh;
  413.     Boolean parent_wants_w,parent_wants_h,we_changed_size;
  414.     
  415.     parent_wants_w = (parent_idea->request_mode) & CWWidth;
  416.     parent_wants_h = (parent_idea->request_mode) & CWHeight;
  417.  
  418.     if (parent_wants_w)
  419.         nw = parent_idea->width;
  420.         else
  421.         nw = MultiListWidth(mlw);
  422.  
  423.     if (parent_wants_h)
  424.         nh = parent_idea->height;
  425.         else
  426.         nh = MultiListHeight(mlw);
  427.  
  428.     our_idea->request_mode = 0;
  429.     if (!parent_wants_w && !parent_wants_h) return(XtGeometryYes);
  430.  
  431.     we_changed_size = Layout(mlw,!parent_wants_w,!parent_wants_h,&nw,&nh);
  432.     our_idea->request_mode |= (CWWidth | CWHeight);
  433.     our_idea->width = nw;
  434.     our_idea->height = nh;
  435.  
  436.     if (we_changed_size)
  437.         return(XtGeometryAlmost);
  438.         else
  439.         return(XtGeometryYes);
  440. } /* End PreferredGeometry */
  441.  
  442.  
  443. /*---------------------------------------------------------------------------*
  444.  
  445.     Resize(mlw)
  446.  
  447.     This function is called when the widget is being resized.  It
  448.     recalculates the layout of the widget.
  449.  
  450.  *---------------------------------------------------------------------------*/
  451.  
  452. static void Resize(mlw)
  453. XfwfMultiListWidget mlw;
  454. {
  455.     Dimension width,height;
  456.  
  457.     width = MultiListWidth(mlw);
  458.     height = MultiListHeight(mlw);
  459.     Layout(mlw,False,False,&width,&height);
  460. } /* End Resize */
  461.  
  462.  
  463. /*---------------------------------------------------------------------------*
  464.  
  465.     SetValues(cpl,rpl,npl)
  466.  
  467.     This routine is called when the user is changing resources.  <cpl>
  468.     is the current widget before the user's changes have been instituted.
  469.     <rpl> includes the original changes as requested by the user.  <npl>
  470.     is the new resulting widget with the requested changes and with all
  471.     superclass changes already made.
  472.  
  473.  *---------------------------------------------------------------------------*/
  474.  
  475. /*ARGSUSED*/
  476. static Boolean SetValues(cpl,rpl,npl)
  477. XfwfMultiListWidget cpl,rpl,npl;
  478. {
  479.     Boolean redraw,recalc;
  480.  
  481.     redraw = False;
  482.     recalc = False;
  483.  
  484.         /* Graphic Context Changes */
  485.  
  486.     if ((MultiListFG(cpl) != MultiListFG(npl)) ||
  487.         (MultiListBG(cpl) != MultiListBG(npl)) ||
  488.         (MultiListHighlightFG(cpl) != MultiListHighlightFG(npl)) ||
  489.         (MultiListHighlightBG(cpl) != MultiListHighlightBG(npl)) ||
  490.         (MultiListFont(cpl) != MultiListFont(npl)))
  491.     {
  492.         XtDestroyGC(MultiListEraseGC(cpl));
  493.         XtDestroyGC(MultiListDrawGC(cpl));
  494.         XtDestroyGC(MultiListHighlightForeGC(cpl));
  495.         XtDestroyGC(MultiListHighlightBackGC(cpl));
  496.         XtDestroyGC(MultiListGrayGC(cpl));
  497.         CreateNewGCs(npl);
  498.         redraw = True;
  499.     }
  500.  
  501.         /* Changes That Require Redraw */
  502.  
  503.     if ((MultiListSensitive(cpl) != MultiListSensitive(npl)) ||
  504.         (MultiListAncesSensitive(cpl) != MultiListAncesSensitive(npl)))
  505.     {
  506.         redraw = True;
  507.     }
  508.  
  509.         /* Changes That Require Selection Changes */
  510.  
  511.     if ((MultiListMaxSelectable(cpl) != MultiListMaxSelectable(npl)))
  512.     {
  513.         XtWarning("Dynamic change to maxSelectable unimplemented");
  514.     }
  515.  
  516.         /* Changes That Require Data Initialization */
  517.  
  518.     if ((MultiListList(cpl) != MultiListList(npl)) ||
  519.         (MultiListNumItems(cpl) != MultiListNumItems(npl)) ||
  520.         (MultiListSensitiveArray(cpl) != MultiListSensitiveArray(npl)))
  521.     {
  522.         DestroyOldData(cpl);
  523.         InitializeNewData(npl);
  524.         recalc = True;
  525.         redraw = True;
  526.     }
  527.  
  528.         /* Changes That Require Recalculating Coordinates */
  529.  
  530.     if ((MultiListWidth(cpl) != MultiListWidth(npl)) ||
  531.         (MultiListHeight(cpl) != MultiListHeight(npl)) ||
  532.         (MultiListColumnSpace(cpl) != MultiListColumnSpace(npl)) ||
  533.         (MultiListRowSpace(cpl) != MultiListRowSpace(npl)) ||
  534.         (MultiListDefaultCols(cpl) != MultiListDefaultCols(npl)) ||
  535.         ((MultiListForceCols(cpl) != MultiListForceCols(npl)) &&
  536.          (MultiListNumCols(cpl) != MultiListNumCols(npl))) ||
  537.         (MultiListRowMajor(cpl) != MultiListRowMajor(npl)) ||
  538.         (MultiListFont(cpl) != MultiListFont(npl)) ||
  539.         (MultiListLongest(cpl) != MultiListLongest(npl)))
  540.     {
  541.         recalc = True;
  542.         redraw = True;
  543.     }
  544.  
  545.     if (MultiListColWidth(cpl) != MultiListColWidth(npl))
  546.     {
  547.         XtWarning("columnWidth Resource Is Read-Only");
  548.         MultiListColWidth(npl) = MultiListColWidth(cpl);
  549.     }
  550.     if (MultiListRowHeight(cpl) != MultiListRowHeight(npl))
  551.     {
  552.         XtWarning("rowHeight Resource Is Read-Only");
  553.         MultiListRowHeight(npl) = MultiListRowHeight(cpl);
  554.     }
  555.  
  556.     if (recalc)
  557.     {
  558.         RecalcCoords(npl,!MultiListWidth(npl),!MultiListHeight(npl));
  559.     }
  560.     
  561.     if (!XtIsRealized((Widget)cpl))
  562.         return(False);
  563.         else
  564.         return(redraw);
  565. } /* End SetValues */
  566.  
  567. /*===========================================================================*
  568.  
  569.                   D A T A    I N I T I A L I Z A T I O N
  570.  
  571.  *===========================================================================*/
  572.  
  573. /*---------------------------------------------------------------------------*
  574.  
  575.     DestroyOldData(mlw)
  576.  
  577.     This routine frees the internal list item array and sets the
  578.     item count to 0.  This is normally done immediately before
  579.     calling InitializeNewData() to rebuild the internal item
  580.     array from new user specified arrays.
  581.  
  582.  *---------------------------------------------------------------------------*/
  583.  
  584. static void DestroyOldData(mlw)
  585. XfwfMultiListWidget mlw;
  586. {
  587.     int i;
  588.  
  589.     if (MultiListItemArray(mlw) != NULL)    /* Free Old List */
  590.     {
  591.         for (i = 0; i < MultiListNumItems(mlw); i++)
  592.         {
  593.             free(MultiListItemString(MultiListNthItem(mlw,i)));
  594.         }
  595.         free((char *)MultiListItemArray(mlw));
  596.     }
  597.     if (MultiListSelArray(mlw) != NULL)
  598.         free((char *)MultiListSelArray(mlw));
  599.     MultiListSelArray(mlw) = NULL;
  600.     MultiListNumSelected(mlw) = 0;
  601.     MultiListItemArray(mlw) = NULL;
  602.     MultiListNumItems(mlw) = 0;
  603. } /* End DestroyOldData */
  604.  
  605.  
  606. /*---------------------------------------------------------------------------*
  607.  
  608.     InitializeNewData(mlw)
  609.  
  610.     This routine takes a MultiList widget <mlw> and builds up new
  611.     data item tables based on the string list and the sensitivity array.
  612.     All previous data should have already been freed.  If the number
  613.     of items is 0, they will be counted, so the array must be NULL
  614.     terminated.  If the list of strings is NULL, this is treated as
  615.     a list of 0 elements.  If the sensitivity array is NULL, all
  616.     items are treated as sensitive.
  617.  
  618.     When this routine is done, the string list and sensitivity array
  619.     fields will all be set to NULL, and the widget will not reference
  620.     them again.
  621.  
  622.  *---------------------------------------------------------------------------*/
  623.  
  624. static void InitializeNewData(mlw)
  625. XfwfMultiListWidget mlw;
  626. {
  627.     int i;
  628.     XfwfMultiListItem *item;
  629.     String *string_array;
  630.  
  631.     string_array = MultiListList(mlw);
  632.     if (string_array == NULL) MultiListNumItems(mlw) = 0;
  633.  
  634.     if (MultiListNumItems(mlw) == 0)        /* Count Elements */
  635.     {
  636.         if (string_array == NULL)        /* No elements */
  637.         {
  638.             MultiListNumItems(mlw) = 0;
  639.         }
  640.             else
  641.         {
  642.             for (i = 0; string_array[i] != NULL; i++);
  643.             MultiListNumItems(mlw) = i;
  644.         }
  645.     }
  646.     if (MultiListNumItems(mlw) == 0)        /* No Items */
  647.     {
  648.         MultiListItemArray(mlw) = NULL;
  649.     }
  650.         else
  651.     {
  652.         MultiListItemArray(mlw) =
  653.             TypeAlloc(XfwfMultiListItem,MultiListNumItems(mlw));
  654.         for (i = 0; i < MultiListNumItems(mlw); i++)
  655.         {
  656.             item = MultiListNthItem(mlw,i);
  657.             if (MultiListSensitiveArray(mlw) == NULL ||
  658.                 (MultiListSensitiveArray(mlw)[i] == True))
  659.             {
  660.                 MultiListItemSensitive(item) = True;
  661.             }
  662.                 else
  663.             {
  664.                 MultiListItemSensitive(item) = False;
  665.             }
  666.             MultiListItemString(item) = StrCopy(string_array[i]);
  667.             MultiListItemHighlighted(item) = False;
  668.         }
  669.     }
  670.     if (MultiListMaxSelectable(mlw) == 0)
  671.     {
  672.         MultiListSelArray(mlw) = NULL;
  673.         MultiListNumSelected(mlw) = 0;
  674.     }
  675.         else
  676.     {
  677.         MultiListSelArray(mlw) =
  678.             TypeAlloc(int,MultiListMaxSelectable(mlw));
  679.         MultiListNumSelected(mlw) = 0;
  680.     }
  681.  
  682.     MultiListList(mlw) = NULL;
  683.     MultiListSensitiveArray(mlw) = NULL;
  684. } /* End InitializeNewData */
  685.         
  686.  
  687. /*---------------------------------------------------------------------------*
  688.  
  689.     CreateNewGCs(mlw)
  690.  
  691.     This routine takes a MultiList widget <mlw> and creates a new set of
  692.     graphic contexts for the widget based on the colors, fonts, etc.
  693.     in the widget.  Any previous GCs are assumed to have already been
  694.     destroyed.
  695.  
  696.  *---------------------------------------------------------------------------*/
  697.  
  698. static void CreateNewGCs(mlw)
  699. XfwfMultiListWidget mlw;
  700. {
  701.     XGCValues values;
  702.     unsigned int attribs;
  703.  
  704.     attribs = GCForeground | GCBackground | GCFont;
  705.     values.foreground = MultiListFG(mlw);
  706.     values.background = MultiListBG(mlw);
  707.     values.font = MultiListFont(mlw)->fid;
  708.     MultiListDrawGC(mlw) = XtGetGC((Widget)mlw,attribs,&values);
  709.  
  710.     values.foreground = MultiListBG(mlw);
  711.     MultiListEraseGC(mlw) = XtGetGC((Widget)mlw,attribs,&values);
  712.  
  713.     values.foreground = MultiListHighlightFG(mlw);
  714.     values.background = MultiListHighlightBG(mlw);
  715.     MultiListHighlightForeGC(mlw) = XtGetGC((Widget)mlw,attribs,&values);
  716.  
  717.     values.foreground = MultiListHighlightBG(mlw);
  718.     values.background = MultiListHighlightBG(mlw);
  719.     MultiListHighlightBackGC(mlw) = XtGetGC((Widget)mlw,attribs,&values);
  720.  
  721.     attribs |= GCTile | GCFillStyle;
  722.     values.foreground = MultiListFG(mlw);
  723.     values.background = MultiListBG(mlw);
  724.     values.fill_style = FillTiled;
  725.     values.tile = XmuCreateStippledPixmap(XtScreen(mlw),MultiListFG(mlw),
  726.                           MultiListBG(mlw),MultiListDepth(mlw));
  727.     MultiListGrayGC(mlw) = XtGetGC((Widget)mlw,attribs,&values);
  728. } /* End CreateNewGCs */
  729.  
  730. /*===========================================================================*
  731.  
  732.         L A Y O U T    A N D    G E O M E T R Y    M A N A G E M E N T
  733.  
  734.  *===========================================================================*/
  735.  
  736. /*---------------------------------------------------------------------------*
  737.  
  738.         RecalcCoords(mlw,width_changeable,height_changeable)
  739.  
  740.     This routine takes a MultiList widget <mlw> and recalculates
  741.     the coordinates, and item placement based on the current
  742.     width, height, and list of items.  The <width_changeable> and
  743.     <height_changeable> indicate if the width and/or height can
  744.     be arbitrarily set.
  745.  
  746.     This routine requires that the internal list data be initialized.
  747.  
  748.  *---------------------------------------------------------------------------*/
  749.  
  750. #if NeedFunctionPrototypes
  751. static void
  752. RecalcCoords(XfwfMultiListWidget mlw,
  753.          Boolean width_changeable, Boolean height_changeable)
  754. #else
  755. static void
  756. RecalcCoords(mlw,width_changeable,height_changeable)
  757. XfwfMultiListWidget mlw;
  758. Boolean width_changeable,height_changeable;
  759. #endif
  760. {
  761.     String str;
  762.     Dimension width,height;
  763.     register int i,text_width;
  764.  
  765.     width = MultiListWidth(mlw);
  766.     height = MultiListHeight(mlw);
  767.     if (MultiListNumItems(mlw) != 0 && MultiListLongest(mlw) == 0)
  768.     {
  769.         for (i = 0; i < MultiListNumItems(mlw); i++)
  770.         {
  771.             str = MultiListItemString(MultiListNthItem(mlw,i));
  772.             text_width = FontW(MultiListFont(mlw),str);
  773.             MultiListLongest(mlw) = max(MultiListLongest(mlw),
  774.                             text_width);
  775.         }
  776.     }
  777.     if (Layout(mlw,width_changeable,height_changeable,&width,&height))
  778.     {
  779.         NegotiateSizeChange(mlw,width,height);
  780.     }
  781. } /* End RecalcCoords */
  782.  
  783.  
  784. /*---------------------------------------------------------------------------*
  785.  
  786.         NegotiateSizeChange(mlw,width,height)
  787.  
  788.     This routine tries to change the MultiList widget <mlw> to have the
  789.     new size <width> by <height>.  A negotiation will takes place
  790.     to try to change the size.  The resulting size is not necessarily
  791.     the requested size.
  792.  
  793.  *---------------------------------------------------------------------------*/
  794.  
  795. #if NeedFunctionPrototypes
  796. static void
  797. NegotiateSizeChange(XfwfMultiListWidget mlw, Dimension width, Dimension height)
  798. #else
  799. static void
  800. NegotiateSizeChange(mlw,width,height)
  801. XfwfMultiListWidget mlw;
  802. Dimension width,height;
  803. #endif
  804. {
  805.     int attempt_number;
  806.     Boolean w_fixed,h_fixed;
  807.     Dimension *w_ptr,*h_ptr;
  808.     
  809.     XtWidgetGeometry request,reply;
  810.  
  811.     request.request_mode = CWWidth | CWHeight;
  812.     request.width = width;
  813.     request.height = height;
  814.     
  815.     for (attempt_number = 1; attempt_number <= 3; attempt_number++)
  816.     {
  817.         switch (XtMakeGeometryRequest((Widget)mlw,&request,&reply))
  818.         {
  819.             case XtGeometryYes:
  820.             case XtGeometryNo:
  821.             return;
  822.             case XtGeometryAlmost:
  823.             switch (attempt_number)
  824.             {
  825.                 case 1:
  826.                 w_fixed = (request.width != reply.width);
  827.                 h_fixed = (request.height != reply.height);
  828.                 w_ptr = &(reply.width);
  829.                 h_ptr = &(reply.height);
  830.                 Layout(mlw,!w_fixed,!h_fixed,w_ptr,h_ptr);
  831.                 break;
  832.                 case 2:
  833.                 w_ptr = &(reply.width);
  834.                 h_ptr = &(reply.height);
  835.                 Layout(mlw,False,False,w_ptr,h_ptr);
  836.                 break;
  837.                 case 3:
  838.                 return;
  839.             }
  840.             break;
  841.             default:
  842.             XtAppWarning(XtWidgetToApplicationContext((Widget)mlw),
  843.                 "MultiList Widget: Unknown geometry return.");
  844.             break;
  845.         }
  846.         request = reply;
  847.     }
  848. } /* End NegotiateSizeChange */
  849.  
  850.  
  851. /*---------------------------------------------------------------------------*
  852.  
  853.     Boolean Layout(mlw,w_changeable,h_changeable,w_ptr,h_ptr)
  854.  
  855.     This routine tries to generate a layout for the MultiList widget
  856.     <mlw>.  The Layout routine is free to arbitrarily set the width
  857.     or height if the corresponding variables <w_changeable> and
  858.     <h_changeable> are set True.  Otherwise the original width or
  859.     height in <w_ptr> and <h_ptr> are used as fixed values.  The
  860.     resulting new width and height are stored back through the
  861.     <w_ptr> and <h_ptr> pointers.  False is returned if no size
  862.     change was done, True is returned otherwise.
  863.  
  864.  *---------------------------------------------------------------------------*/
  865.  
  866. #if NeedFunctionPrototypes
  867. static Boolean
  868. Layout(XfwfMultiListWidget mlw, Boolean w_changeable, Boolean h_changeable,
  869.        Dimension *w_ptr, Dimension *h_ptr)
  870. #else
  871. static Boolean
  872. Layout(mlw,w_changeable,h_changeable,w_ptr,h_ptr)
  873. XfwfMultiListWidget mlw;
  874. Boolean w_changeable,h_changeable;
  875. Dimension *w_ptr,*h_ptr;
  876. #endif
  877. {
  878.     Boolean size_changed = False;
  879.  
  880.     /*
  881.      * If force columns is set, then always use the number
  882.      * of columns specified by default_cols.
  883.      */
  884.  
  885.     MultiListColWidth(mlw) = MultiListLongest(mlw) +
  886.         MultiListColumnSpace(mlw);
  887.     MultiListRowHeight(mlw) = FontH(MultiListFont(mlw)) +
  888.         MultiListRowSpace(mlw);
  889.     if (MultiListForceCols(mlw))
  890.     {
  891.         MultiListNumCols(mlw) = max(MultiListDefaultCols(mlw),1);
  892.         if (MultiListNumItems(mlw) == 0)
  893.             MultiListNumRows(mlw) = 1;
  894.             else
  895.             MultiListNumRows(mlw) = (MultiListNumItems(mlw) - 1) /
  896.                 MultiListNumCols(mlw) + 1;
  897.         if (w_changeable)
  898.         {
  899.             *w_ptr = MultiListNumCols(mlw) *
  900.                 MultiListColWidth(mlw);
  901.             size_changed = True;
  902.         }
  903.             else
  904.         {
  905.             MultiListColWidth(mlw) = *w_ptr /
  906.                 (Dimension)MultiListNumCols(mlw);
  907.         }
  908.         if (h_changeable)
  909.         {
  910.             *h_ptr = MultiListNumRows(mlw) *
  911.                 MultiListRowHeight(mlw);
  912.             size_changed = True;
  913.         }
  914.         return(size_changed);
  915.     }
  916.  
  917.     /*
  918.      * If both width and height are free to change then use
  919.      * default_cols to determine the number of columns and set
  920.      * the new width and height to just fit the window.
  921.      */
  922.  
  923.     if (w_changeable && h_changeable)
  924.     {
  925.         MultiListNumCols(mlw) = max(MultiListDefaultCols(mlw),1);
  926.         if (MultiListNumItems(mlw) == 0)
  927.             MultiListNumRows(mlw) = 1;
  928.             else
  929.             MultiListNumRows(mlw) = (MultiListNumItems(mlw) - 1) /
  930.                 MultiListNumCols(mlw) + 1;
  931.         *w_ptr = MultiListNumCols(mlw) * MultiListColWidth(mlw);
  932.         *h_ptr = MultiListNumRows(mlw) * MultiListRowHeight(mlw);
  933.         return(True);
  934.     }
  935.  
  936.     /*
  937.      * If the width is fixed then use it to determine the
  938.      * number of columns.  If the height is free to move
  939.      * (width still fixed) then resize the height of the
  940.      * widget to fit the current MultiList exactly.
  941.      */
  942.  
  943.     if (!w_changeable)
  944.     {
  945.         MultiListNumCols(mlw) = *w_ptr / MultiListColWidth(mlw);
  946.         MultiListNumCols(mlw) = max(MultiListNumCols(mlw),1);
  947.         MultiListNumRows(mlw) = (MultiListNumItems(mlw) - 1) /
  948.             MultiListNumCols(mlw) + 1;
  949.         MultiListColWidth(mlw) = *w_ptr / (Dimension)MultiListNumCols(mlw);
  950.         if (h_changeable)
  951.         {
  952.             *h_ptr = MultiListNumRows(mlw) * MultiListRowHeight(mlw);
  953.             size_changed = True;
  954.         }
  955.         return(size_changed);
  956.     }
  957.  
  958.     /*
  959.      * The last case is xfree and !yfree we use the height to
  960.      * determine the number of rows and then set the width to
  961.      * just fit the resulting number of columns.
  962.      */
  963.  
  964.     MultiListNumRows(mlw) = *h_ptr / MultiListRowHeight(mlw);
  965.     MultiListNumRows(mlw) = max(MultiListNumRows(mlw),1);
  966.     MultiListNumCols(mlw) = (MultiListNumItems(mlw) - 1) /
  967.         MultiListNumRows(mlw) + 1;
  968.     *w_ptr = MultiListNumCols(mlw) * MultiListColWidth(mlw);
  969.     return(True);
  970. } /* End Layout */
  971.  
  972. /*===========================================================================*
  973.  
  974.                     R E D R A W    R O U T I N E S
  975.  
  976.  *===========================================================================*/
  977.  
  978. /*---------------------------------------------------------------------------*
  979.  
  980.     RedrawAll(mlw)
  981.  
  982.     This routine simple calls Redisplay to redraw the entire
  983.     MultiList widget <mlw>.
  984.  
  985.  *---------------------------------------------------------------------------*/
  986.  
  987. static void RedrawAll(mlw)
  988. XfwfMultiListWidget mlw;
  989. {
  990.     Redisplay(mlw,NULL,NULL);
  991. } /* End RedrawAll */
  992.  
  993.  
  994. /*---------------------------------------------------------------------------*
  995.  
  996.     RedrawItem(mlw,item_index)
  997.  
  998.     This routine redraws the item with index <item_index> in the
  999.     MultiList widget <mlw>.  If the item number is bad, nothing is drawn.
  1000.  
  1001.  *---------------------------------------------------------------------------*/
  1002.  
  1003. static void RedrawItem(mlw,item_index)
  1004. XfwfMultiListWidget mlw;
  1005. int item_index;
  1006. {
  1007.     int row,column;
  1008.  
  1009.     if (ItemToRowColumn(mlw,item_index,&row,&column))
  1010.     {
  1011.         RedrawRowColumn(mlw,row,column);
  1012.     }
  1013. } /* End RedrawItem */
  1014.  
  1015.  
  1016. /*---------------------------------------------------------------------------*
  1017.  
  1018.     RedrawRowColumn(mlw,row,column)
  1019.  
  1020.     This routine paints the item in row/column position <row>,<column>
  1021.     on the MultiList widget <mlw>.  If the row/column coordinates are
  1022.     outside the widget, nothing is drawn.  If the position is empty,
  1023.     blank space is drawn.
  1024.  
  1025.  *---------------------------------------------------------------------------*/
  1026.  
  1027. static void RedrawRowColumn(mlw,row,column)
  1028. XfwfMultiListWidget mlw;
  1029. int row,column;
  1030. {
  1031.     GC bg_gc,fg_gc;
  1032.     XfwfMultiListItem *item;
  1033.     int ul_x,ul_y,str_x,str_y,w,h,item_index,has_item,text_h;
  1034.  
  1035.     if (!XtIsRealized((Widget)mlw)) return;
  1036.     has_item = RowColumnToItem(mlw,row,column,&item_index);
  1037.     RowColumnToPixels(mlw,row,column,&ul_x,&ul_y,&w,&h);
  1038.  
  1039.     if (has_item == False)                    /* No Item */
  1040.     {
  1041.         if (MultiListShadeSurplus(mlw))
  1042.             bg_gc = MultiListGrayGC(mlw);
  1043.             else
  1044.             bg_gc = MultiListEraseGC(mlw);
  1045.     }
  1046.         else
  1047.     {
  1048.         item = MultiListNthItem(mlw,item_index);
  1049.         if ((!MultiListSensitive(mlw)) ||
  1050.             (!MultiListItemSensitive(item)))    /* Insensitive */
  1051.         {
  1052.                 if (MultiListItemHighlighted(item))    /* Selected */
  1053.             {
  1054.                 bg_gc = MultiListGrayGC(mlw);
  1055.                 fg_gc = MultiListEraseGC(mlw);
  1056.             }
  1057.                 else                /* !Selected */
  1058.             {
  1059.                 bg_gc = MultiListEraseGC(mlw);
  1060.                 fg_gc = MultiListGrayGC(mlw);
  1061.             }
  1062.         }
  1063.             else                /* Sensitive */
  1064.         {
  1065.                 if (MultiListItemHighlighted(item))    /* Selected */
  1066.             {
  1067.                 bg_gc = MultiListHighlightBackGC(mlw);
  1068.                 fg_gc = MultiListHighlightForeGC(mlw);
  1069.             }
  1070.                 else                /* !Selected */
  1071.             {
  1072.                 bg_gc = MultiListEraseGC(mlw);
  1073.                 fg_gc = MultiListDrawGC(mlw);
  1074.             }
  1075.         }
  1076.     }
  1077.     XFillRectangle(XtDisplay(mlw),XtWindow(mlw),bg_gc,ul_x,ul_y,w,h);
  1078.     if (has_item == True)
  1079.     {
  1080.         text_h = min(FontH(MultiListFont(mlw)) +
  1081.                  (int)MultiListRowSpace(mlw),(int)MultiListRowHeight(mlw));
  1082.         str_x = ul_x + MultiListColumnSpace(mlw) / 2;
  1083.         str_y = ul_y + FontAscent(MultiListFont(mlw)) +
  1084.             ((int)MultiListRowHeight(mlw) - text_h) / 2;
  1085.         XDrawString(XtDisplay(mlw),XtWindow(mlw),fg_gc,
  1086.                 str_x,str_y,MultiListItemString(item),
  1087.                 strlen(MultiListItemString(item)));
  1088.     }
  1089. } /* End RedrawRowColumn */
  1090.     
  1091. /*===========================================================================*
  1092.  
  1093.                I T E M    L O C A T I O N    R O U T I N E S
  1094.  
  1095.  *===========================================================================*/
  1096.  
  1097. /*---------------------------------------------------------------------------*
  1098.  
  1099.     void PixelToRowColumn(mlw,x,y,row_ptr,column_ptr)
  1100.  
  1101.     This routine takes pixel coordinates <x>, <y> and converts
  1102.     the pixel coordinate into a row/column coordinate.  This row/column
  1103.     coordinate can then easily be converted into the specific item
  1104.     in the list via the function RowColumnToItem().
  1105.  
  1106.     If the pixel lies in blank space outside of the items, the
  1107.     row & column numbers will be outside of the range of normal
  1108.     row & columns numbers, but will correspond to the row & column
  1109.     of the item, if an item was actually there.
  1110.  
  1111.  *---------------------------------------------------------------------------*/
  1112.  
  1113. static void PixelToRowColumn(mlw,x,y,row_ptr,column_ptr)
  1114. XfwfMultiListWidget mlw;
  1115. int x,y,*row_ptr,*column_ptr;
  1116. {
  1117.     *row_ptr = y / (int)MultiListRowHeight(mlw);
  1118.     *column_ptr = x / (int)MultiListColWidth(mlw);
  1119. } /* End PixelToRowColumn */
  1120.  
  1121. /*---------------------------------------------------------------------------*
  1122.  
  1123.     void RowColumnToPixels(mlw,row,col,x_ptr,y_ptr,w_ptr,h_ptr)
  1124.  
  1125.     This routine takes a row/column coordinate <row>,<col> and
  1126.     converts it into the bounding pixel rectangle which is returned.
  1127.  
  1128.  *---------------------------------------------------------------------------*/
  1129.  
  1130. static void RowColumnToPixels(mlw,row,col,x_ptr,y_ptr,w_ptr,h_ptr)
  1131. XfwfMultiListWidget mlw;
  1132. int row,col,*x_ptr,*y_ptr,*w_ptr,*h_ptr;
  1133. {
  1134.     *x_ptr = col * MultiListColWidth(mlw);
  1135.     *y_ptr = row * MultiListRowHeight(mlw);
  1136.     *w_ptr = MultiListColWidth(mlw);
  1137.     *h_ptr = MultiListRowHeight(mlw);
  1138. } /* End RowColumnToPixels */
  1139.  
  1140. /*---------------------------------------------------------------------------*
  1141.  
  1142.     Boolean RowColumnToItem(mlw,row,column,item_ptr)
  1143.  
  1144.     This routine takes a row number <row> and a column number <column>
  1145.     and tries to resolve this row and column into the index of the
  1146.     item in this position of the MultiList widget <mlw>.  The resulting
  1147.     item index is placed through <item_ptr>.  If there is no item at
  1148.     this location, False is returned, else True is returned.
  1149.  
  1150.  *---------------------------------------------------------------------------*/
  1151.  
  1152. static Boolean RowColumnToItem(mlw,row,column,item_ptr)
  1153. XfwfMultiListWidget mlw;
  1154. int row,column,*item_ptr;
  1155. {
  1156.     register int x_stride,y_stride;
  1157.  
  1158.     if (row < 0 || row >= MultiListNumRows(mlw) ||
  1159.         column < 0 || column >= MultiListNumCols(mlw))
  1160.     {
  1161.         return(False);
  1162.     }
  1163.     if (MultiListRowMajor(mlw))
  1164.     {
  1165.         x_stride = 1;
  1166.         y_stride = MultiListNumCols(mlw);
  1167.     }
  1168.         else
  1169.     {
  1170.         x_stride = MultiListNumRows(mlw);
  1171.         y_stride = 1;
  1172.     }
  1173.     *item_ptr = row * y_stride + column * x_stride;
  1174.     if (*item_ptr >= MultiListNumItems(mlw))
  1175.         return(False);
  1176.         else
  1177.         return(True);
  1178. } /* End RowColumnToItem */
  1179.  
  1180.  
  1181. /*---------------------------------------------------------------------------*
  1182.  
  1183.     Boolean ItemToRowColumn(mlw,item_index,row_ptr,column_ptr)
  1184.  
  1185.     This routine takes an item number <item_index> and attempts
  1186.     to convert the index into row and column numbers stored through
  1187.     <row_ptr> and <column_ptr>.  If the item number does not
  1188.     corespond to a valid item, False is returned, else True is
  1189.     returned.
  1190.  
  1191.  *---------------------------------------------------------------------------*/
  1192.  
  1193. static Boolean ItemToRowColumn(mlw,item_index,row_ptr,column_ptr)
  1194. XfwfMultiListWidget mlw;
  1195. int item_index,*row_ptr,*column_ptr;
  1196. {
  1197.     if (item_index < 0 || item_index >= MultiListNumItems(mlw))
  1198.     {
  1199.         return(False);
  1200.     }
  1201.     if (MultiListRowMajor(mlw))
  1202.     {
  1203.         *row_ptr = item_index / MultiListNumCols(mlw);
  1204.         *column_ptr = item_index % MultiListNumCols(mlw);
  1205.     }
  1206.         else
  1207.     {
  1208.         *row_ptr = item_index % MultiListNumRows(mlw);
  1209.         *column_ptr = item_index / MultiListNumRows(mlw);
  1210.     }
  1211.     return(True);
  1212. } /* End ItemToRowColumn */
  1213.  
  1214. /*===========================================================================*
  1215.  
  1216.                 E V E N T    A C T I O N    H A N D L E R S
  1217.  
  1218.  *===========================================================================*/
  1219.  
  1220. /*---------------------------------------------------------------------------*
  1221.  
  1222.     Select(mlw,event,params,num_params)
  1223.  
  1224.     This action handler is called when a user selects an item in the
  1225.     MultiList.  This action first unselects all previously selected
  1226.     items, then selects the item under the mouse, if it is not a
  1227.     background gap, and if it is sensitive.
  1228.  
  1229.     The MultiListMostRecentItem(mlw) variable will be set to the
  1230.     item clicked on, or -1 if the item is background or insensitive.
  1231.     The MultiListMostRecentAct(mlw) variable will be set to
  1232.     XfwfMultiListActionHighlight, in case the selection region is extended.
  1233.  
  1234.  *---------------------------------------------------------------------------*/
  1235.  
  1236. /* ARGSUSED */
  1237. static void Select(mlw,event,params,num_params)
  1238. XfwfMultiListWidget mlw;
  1239. XEvent *event;
  1240. String *params;
  1241. Cardinal *num_params;
  1242. {
  1243.     int click_x,click_y;
  1244.     int status,item_index,row,column;
  1245.  
  1246.     click_x = event->xbutton.x;
  1247.     click_y = event->xbutton.y;
  1248.     PixelToRowColumn(mlw,click_x,click_y,&row,&column);
  1249.     XfwfMultiListUnhighlightAll(mlw);
  1250.     MultiListMostRecentAct(mlw) = XfwfMultiListActionHighlight;
  1251.     status = RowColumnToItem(mlw,row,column,&item_index);
  1252.     if ((status == False) ||
  1253.         (!MultiListItemSensitive(MultiListNthItem(mlw,item_index))))
  1254.     {
  1255.         MultiListMostRecentItem(mlw) = -1;
  1256.     }
  1257.         else
  1258.     {
  1259.         MultiListMostRecentItem(mlw) = item_index;
  1260.         XfwfMultiListHighlightItem(mlw,item_index);
  1261.     }
  1262. } /* End Select */
  1263.  
  1264.  
  1265. /*---------------------------------------------------------------------------*
  1266.  
  1267.     Unselect(mlw,event,params,num_params)
  1268.  
  1269.     This function unselects the single text item pointed to by the
  1270.     mouse, if any.  Any remaining selected entries are left selected.
  1271.  
  1272.     The MultiListMostRecentItem(mlw) variable will be set to -1, and
  1273.     the MultiListMostRecentAct(mlw) variable will be set to
  1274.     XfwfMultiListActionUnhighlight, in case the deselection region is
  1275.     extended.
  1276.     
  1277.  *---------------------------------------------------------------------------*/
  1278.  
  1279. /* ARGSUSED */
  1280. static void Unselect(mlw,event,params,num_params)
  1281. XfwfMultiListWidget mlw;
  1282. XEvent *event;
  1283. String *params;
  1284. Cardinal *num_params;
  1285. {
  1286.     int click_x,click_y;
  1287.     int status,item_index,row,column;
  1288.  
  1289.     click_x = event->xbutton.x;
  1290.     click_y = event->xbutton.y;
  1291.     PixelToRowColumn(mlw,click_x,click_y,&row,&column);
  1292.     MultiListMostRecentItem(mlw) = -1;
  1293.     MultiListMostRecentAct(mlw) = XfwfMultiListActionUnhighlight;
  1294.     status = RowColumnToItem(mlw,row,column,&item_index);
  1295.     if ((status == True) &&
  1296.         (MultiListItemSensitive(MultiListNthItem(mlw,item_index))))
  1297.         XfwfMultiListHighlightItem(mlw,item_index);
  1298. } /* End Unselect */
  1299.  
  1300.  
  1301. /*---------------------------------------------------------------------------*
  1302.  
  1303.     Toggle(mlw,event,params,num_params)
  1304.  
  1305.     This action handler implements the toggling of selection status
  1306.     for a single item.  Any remaining selected entries are left selected.
  1307.  
  1308.     If the mouse is not over a selectable text item, the
  1309.     MultiListMostRecentAct(mlw) variable is set to
  1310.     XfwfMultiListActionHighlight, in case the region is extended into
  1311.     selectable items later.  MultiListMostRecentItem(mlw) is set to -1.
  1312.  
  1313.     If the mouse is over a selectable text item, the item highlight is
  1314.     toggled.  If the item is currently selected, it becomes deselected.
  1315.     If unselected, the item becomes selected.  At the same time, the
  1316.     MultiListMostRecentAct(mlw) variable is set to
  1317.     XfwfMultiListActionHighlight if the item was not previously selected,
  1318.     or XfwfMultiListActionUnhighlight if the item was previously selected.
  1319.     MultiListMostRecentItem(mlw) is set to the index of the item clicked
  1320.     on if the item is selected, or -1 if it is unselected.
  1321.  
  1322.  *---------------------------------------------------------------------------*/
  1323.  
  1324. /* ARGSUSED */
  1325. static void Toggle(mlw,event,params,num_params)
  1326. XfwfMultiListWidget mlw;
  1327. XEvent *event;
  1328. String *params;
  1329. Cardinal *num_params;
  1330. {
  1331.     int click_x,click_y;
  1332.     int status,item_index,row,column;
  1333.  
  1334.     click_x = event->xbutton.x;
  1335.     click_y = event->xbutton.y;
  1336.     PixelToRowColumn(mlw,click_x,click_y,&row,&column);
  1337.     status = RowColumnToItem(mlw,row,column,&item_index);
  1338.     if ((status == False) ||
  1339.         (!MultiListItemSensitive(MultiListNthItem(mlw,item_index))))
  1340.     {
  1341.         MultiListMostRecentAct(mlw) = XfwfMultiListActionHighlight;
  1342.         MultiListMostRecentItem(mlw) = -1;
  1343.     }
  1344.         else
  1345.     {
  1346.         MultiListMostRecentAct(mlw) =
  1347.             XfwfMultiListToggleItem(mlw,item_index);
  1348.         MultiListMostRecentItem(mlw) = item_index;
  1349.     }
  1350. } /* End Toggle */
  1351.  
  1352.  
  1353. /*---------------------------------------------------------------------------*
  1354.  
  1355.     Extend(mlw,event,params,num_params)
  1356.  
  1357.     This action handler implements the extension of a selection/
  1358.     deselection region.
  1359.  
  1360.     The MultiListMostRecentAct(mlw) variable is used to determine
  1361.     if items are to be selected or unselected.  This routine performs
  1362.     select or unselect actions on each item it is called on.
  1363.  
  1364.  *---------------------------------------------------------------------------*/
  1365.  
  1366. /* ARGSUSED */
  1367. static void Extend(mlw,event,params,num_params)
  1368. XfwfMultiListWidget mlw;
  1369. XEvent *event;
  1370. String *params;
  1371. Cardinal *num_params;
  1372. {
  1373.     int click_x,click_y;
  1374.     int status,item_index,row,column;
  1375.  
  1376.     click_x = ((XMotionEvent*)event)->x;
  1377.     click_y = ((XMotionEvent*)event)->y;
  1378.     PixelToRowColumn(mlw,click_x,click_y,&row,&column);
  1379.     status = RowColumnToItem(mlw,row,column,&item_index);
  1380.     if ((status == True) &&
  1381.         (MultiListItemSensitive(MultiListNthItem(mlw,item_index))))
  1382.     {
  1383.         MultiListMostRecentItem(mlw) = item_index;
  1384.         if (MultiListMostRecentAct(mlw) == XfwfMultiListActionHighlight)
  1385.             XfwfMultiListHighlightItem(mlw,item_index);
  1386.             else
  1387.             XfwfMultiListUnhighlightItem(mlw,item_index);
  1388.     }
  1389. } /* End Extend */
  1390.  
  1391.  
  1392. /*---------------------------------------------------------------------------*
  1393.  
  1394.     Notify(mlw,event,params,num_params)
  1395.  
  1396.     This function performs the Notify action, which issues a callback
  1397.     after a selection/unselection has completed.  All callbacks on the
  1398.     callback list are invoked, and a XfxfMultiListReturnStruct describing
  1399.     the selection state is returned.
  1400.  
  1401.     In addition, if the XtNpasteBuffer resource is true and at least one
  1402.     text item is selected, all the selected items are placed in the X
  1403.     cut buffer (buf(0)) separated by newlines.
  1404.  
  1405.  *---------------------------------------------------------------------------*/
  1406.  
  1407. /* ARGSUSED */
  1408. static void Notify(mlw,event,params,num_params)
  1409. XfwfMultiListWidget mlw;
  1410. XEvent *event;
  1411. String *params;
  1412. Cardinal *num_params;
  1413. {
  1414.     char *buffer;
  1415.     String string;
  1416.     int i,byte_count,item_index;
  1417.     XfwfMultiListReturnStruct ret_value;
  1418.  
  1419.     if ((MultiListNumSelected(mlw) != 0) && MultiListPaste(mlw))
  1420.     {
  1421.         byte_count = 0;
  1422.         for (i = 0; i < MultiListNumSelected(mlw); i++)
  1423.         {
  1424.             item_index = MultiListSelArray(mlw)[i];
  1425.             string = MultiListItemString(MultiListNthItem(mlw,
  1426.                 item_index));
  1427.             byte_count = byte_count + strlen(string) + 1;
  1428.         }
  1429.         buffer = (char *)malloc(byte_count);
  1430.         buffer[0] = '\0';
  1431.         for (i = 0; i < MultiListNumSelected(mlw); i++)
  1432.         {
  1433.             if (i != 0) strcat(buffer,"\n");
  1434.             item_index = MultiListSelArray(mlw)[i];
  1435.             string = MultiListItemString(MultiListNthItem(mlw,
  1436.                 item_index));
  1437.             strcat(buffer,string);
  1438.         }
  1439.         XStoreBytes(XtDisplay(mlw),buffer,byte_count);
  1440.         free(buffer);
  1441.     }
  1442.  
  1443.     ret_value.action = MultiListMostRecentAct(mlw);
  1444.     ret_value.item = MultiListMostRecentItem(mlw);
  1445.     if (ret_value.item == -1)
  1446.         ret_value.string = NULL;
  1447.         else
  1448.         ret_value.string = MultiListItemString(MultiListNthItem(mlw,
  1449.             ret_value.item));
  1450.     ret_value.num_selected = MultiListNumSelected(mlw);
  1451.     ret_value.selected_items = MultiListSelArray(mlw);
  1452.     XtCallCallbacks((Widget)mlw,XtNcallback,(caddr_t)&ret_value);
  1453. } /* End Notify */
  1454.  
  1455. /*===========================================================================*
  1456.  
  1457.         U S E R    C A L L A B L E    U T I L I T Y    R O U T I N E S
  1458.  
  1459.  *===========================================================================*/
  1460.  
  1461. /*---------------------------------------------------------------------------*
  1462.  
  1463.     Boolean XfwfMultiListHighlightItem(mlw,item_index)
  1464.  
  1465.     This routine selects an item with index <item_index> in the
  1466.     MultiList widget <mlw>.  If a maximum number of selections is specified
  1467.     and exceeded, the earliest selection will be unselected.  If
  1468.     <item_index> doesn't correspond to an item the most recently
  1469.     clicked item will be set to -1 and this routine will immediately
  1470.     return, otherwise the most recently clicked item will be set to the
  1471.     current item.  If the clicked on item is not sensitive, or if the
  1472.     click is not on an item, False is returned, else True is returned.
  1473.  
  1474.  *---------------------------------------------------------------------------*/
  1475.  
  1476. Boolean XfwfMultiListHighlightItem(mlw,item_index)
  1477. XfwfMultiListWidget mlw;
  1478. int item_index;
  1479. {
  1480.     XfwfMultiListItem *item;
  1481.  
  1482.     if (MultiListMaxSelectable(mlw) == 0) return(False);
  1483.     if (item_index < 0 || item_index >= MultiListNumItems(mlw))
  1484.     {
  1485.         MultiListMostRecentItem(mlw) = -1;
  1486.         return(False);
  1487.     }
  1488.     item = MultiListNthItem(mlw,item_index);
  1489.     if (MultiListItemSensitive(item) == False) return(False);
  1490.     MultiListMostRecentItem(mlw) = item_index;
  1491.     if (MultiListItemHighlighted(item) == True) return(True);
  1492.     if (MultiListNumSelected(mlw) == MultiListMaxSelectable(mlw))
  1493.     {
  1494.         XfwfMultiListUnhighlightItem(mlw,MultiListSelArray(mlw)[0]);
  1495.     }
  1496.     MultiListItemHighlighted(item) = True;
  1497.     MultiListSelArray(mlw)[MultiListNumSelected(mlw)] = item_index;
  1498.     ++ MultiListNumSelected(mlw);
  1499.     RedrawItem(mlw,item_index);
  1500.     return(True);
  1501. } /* End XfwfMultiListHighlightItem */
  1502.  
  1503.  
  1504. /*---------------------------------------------------------------------------*
  1505.  
  1506.     XfwfMultiListHighlightAll(mlw)
  1507.  
  1508.     This routine highlights all highlightable items in the MultiList
  1509.     widget <mlw>, up to the maximum number of allowed highlightable
  1510.     items;
  1511.  
  1512.  *---------------------------------------------------------------------------*/
  1513.  
  1514. void XfwfMultiListHighlightAll(mlw)
  1515. XfwfMultiListWidget mlw;
  1516. {
  1517.     int i;
  1518.     XfwfMultiListItem *item;
  1519.  
  1520.     MultiListNumSelected(mlw) = 0;
  1521.     for (i = 0; i < MultiListNumItems(mlw); i++)
  1522.     {
  1523.         item = MultiListNthItem(mlw,i);
  1524.         MultiListItemHighlighted(item) = False;
  1525.     }
  1526.     for (i = 0; i < MultiListNumItems(mlw); i++)
  1527.     {
  1528.         if (MultiListNumSelected(mlw) == MultiListMaxSelectable(mlw))
  1529.             break;
  1530.         item = MultiListNthItem(mlw,i);
  1531.         if (MultiListItemSensitive(item) == False) continue;
  1532.         MultiListItemHighlighted(item) = True;
  1533.         MultiListSelArray(mlw)[MultiListNumSelected(mlw)] = i;
  1534.         ++ MultiListNumSelected(mlw);
  1535.     }
  1536.     RedrawAll(mlw);
  1537. } /* End XfwfMultiListHighlightAll */
  1538.  
  1539.  
  1540. /*---------------------------------------------------------------------------*
  1541.  
  1542.     XfwfMultiListUnhighlightItem(mlw,item_index)
  1543.  
  1544.     This routine unselects the item with index <item_index> in the
  1545.     MultiList widget <mlw>.  If <item_index> doesn't correspond to a
  1546.     selected item, then nothing will happen.  Otherwise, the item
  1547.     is unselected and the selection array and count are updated.
  1548.  
  1549.  *---------------------------------------------------------------------------*/
  1550.  
  1551. void XfwfMultiListUnhighlightItem(mlw,item_index)
  1552. XfwfMultiListWidget mlw;
  1553. int item_index;
  1554. {
  1555.     int i;
  1556.     XfwfMultiListItem *item;
  1557.  
  1558.     if (MultiListMaxSelectable(mlw) == 0) return;
  1559.     if (item_index < 0 || item_index >= MultiListNumItems(mlw)) return;
  1560.     item = MultiListNthItem(mlw,item_index);
  1561.     if (MultiListItemHighlighted(item) == False) return;
  1562.     MultiListItemHighlighted(item) = False;
  1563.  
  1564.     for (i = 0; i < MultiListNumSelected(mlw); i++)
  1565.         if (MultiListSelArray(mlw)[i] == item_index) break;
  1566.     for (i = i + 1; i < MultiListNumSelected(mlw); i++)
  1567.         MultiListSelArray(mlw)[i - 1] = MultiListSelArray(mlw)[i];
  1568.     -- MultiListNumSelected(mlw);
  1569.  
  1570.     RedrawItem(mlw,item_index);
  1571. } /* End XfwfMultiListUnhighlightItem */
  1572.  
  1573.  
  1574. /*---------------------------------------------------------------------------*
  1575.  
  1576.     XfwfMultiListUnhighlightAll(mlw)
  1577.  
  1578.     This routine unhighlights all items in the MultiList widget <mlw>.
  1579.  
  1580.  *---------------------------------------------------------------------------*/
  1581.  
  1582. void XfwfMultiListUnhighlightAll(mlw)
  1583. XfwfMultiListWidget mlw;
  1584. {
  1585.     int i;
  1586.     XfwfMultiListItem *item;
  1587.  
  1588.     for (i = 0; i < MultiListNumItems(mlw); i++)
  1589.     {
  1590.         item = MultiListNthItem(mlw,i);
  1591.         if (MultiListItemHighlighted(item))
  1592.             XfwfMultiListUnhighlightItem(mlw,i);
  1593.     }
  1594.     MultiListNumSelected(mlw) = 0;
  1595. } /* End XfwfMultiListUnhighlightAll */
  1596.  
  1597.  
  1598. /*---------------------------------------------------------------------------*
  1599.  
  1600.     int XfwfMultiListToggleItem(mlw,item_index)
  1601.  
  1602.     This routine highlights the item with index <item_index>
  1603.     if it is unhighlighted and unhighlights it if it is already
  1604.     highlighted.  The action performed by the toggle is returned
  1605.     (XfwfMultiListActionHighlight or XfwfMultiListActionUnhighlight).
  1606.  
  1607.  *---------------------------------------------------------------------------*/
  1608.  
  1609. int XfwfMultiListToggleItem(mlw,item_index)
  1610. XfwfMultiListWidget mlw;
  1611. int item_index;
  1612. {
  1613.     XfwfMultiListItem *item;
  1614.  
  1615.     if (MultiListMaxSelectable(mlw) == 0)
  1616.         return(XfwfMultiListActionNothing);
  1617.     if (item_index < 0 || item_index >= MultiListNumItems(mlw))
  1618.         return(XfwfMultiListActionNothing);
  1619.     item = MultiListNthItem(mlw,item_index);
  1620.     if (MultiListItemSensitive(item) == False)
  1621.         return(XfwfMultiListActionNothing);
  1622.     if (MultiListItemHighlighted(item))
  1623.     {
  1624.         XfwfMultiListUnhighlightItem(mlw,item_index);
  1625.         return(XfwfMultiListActionUnhighlight);
  1626.     }
  1627.         else
  1628.     {
  1629.         XfwfMultiListHighlightItem(mlw,item_index);
  1630.         return(XfwfMultiListActionHighlight);
  1631.     }
  1632. } /* End XfwfMultiListToggleItem */
  1633.  
  1634.  
  1635. /*---------------------------------------------------------------------------*
  1636.  
  1637.     XfwfMultiListReturnStruct *XfwfMultiListGetHighlighted(mlw)
  1638.  
  1639.     This routine takes a MultiList widget <mlw> and returns a
  1640.     XfwfMultiListReturnStruct whose num_selected and selected_items
  1641.     fields contain the highlight information.  The action field
  1642.     is set to MULTILIST_ACTION_STATUS, and the item_index and string
  1643.     fields are invalid.
  1644.  
  1645.  *---------------------------------------------------------------------------*/
  1646.  
  1647. XfwfMultiListReturnStruct *XfwfMultiListGetHighlighted(mlw)
  1648. XfwfMultiListWidget mlw;
  1649. {
  1650.     XfwfMultiListItem *item;
  1651.     static XfwfMultiListReturnStruct ret_value;
  1652.  
  1653.     ret_value.action = XfwfMultiListActionStatus;
  1654.     if (MultiListNumSelected(mlw) == 0)
  1655.     {
  1656.         ret_value.item = -1;
  1657.         ret_value.string = NULL;
  1658.     }
  1659.         else
  1660.     {
  1661.         ret_value.item = MultiListSelArray(mlw)
  1662.             [MultiListNumSelected(mlw) - 1];
  1663.         item = MultiListNthItem(mlw,ret_value.item);
  1664.         ret_value.string = MultiListItemString(item);
  1665.     }
  1666.     ret_value.num_selected = MultiListNumSelected(mlw);
  1667.     ret_value.selected_items = MultiListSelArray(mlw);
  1668.     return(&ret_value);
  1669. } /* End XfwfMultiListGetHighlighted */
  1670.  
  1671.  
  1672. /*---------------------------------------------------------------------------*
  1673.  
  1674.     Boolean XfwfMultiListIsHighlighted(mlw,item_index)
  1675.  
  1676.     This routine checks if the item with index <item_index>
  1677.     is highlighted and returns True or False depending.  If
  1678.     <item_index> is invalid, False is returned.
  1679.  
  1680.  *---------------------------------------------------------------------------*/
  1681.  
  1682. Boolean XfwfMultiListIsHighlighted(mlw,item_index)
  1683. XfwfMultiListWidget mlw;
  1684. int item_index;
  1685. {
  1686.     XfwfMultiListItem *item;
  1687.  
  1688.     if (item_index < 0 || item_index >= MultiListNumItems(mlw))
  1689.         return(False);
  1690.     item = MultiListNthItem(mlw,item_index);
  1691.     return(MultiListItemHighlighted(item));
  1692. } /* End XfwfMultiListIsHighlighted */
  1693.  
  1694.  
  1695. /*---------------------------------------------------------------------------*
  1696.  
  1697.     Boolean XfwfMultiListGetItemInfo(mlw,item_index,str_ptr,h_ptr,s_ptr)
  1698.  
  1699.     This routine returns the string, highlight status and
  1700.     sensitivity information for the item with index <item_index>
  1701.     via the pointers <str_ptr>, <h_ptr> and <s_ptr>.  If the item
  1702.     index is invalid, False is returned, else True is returned.
  1703.  
  1704.  *---------------------------------------------------------------------------*/
  1705.  
  1706. Boolean XfwfMultiListGetItemInfo(mlw,item_index,str_ptr,h_ptr,s_ptr)
  1707. XfwfMultiListWidget mlw;
  1708. int item_index;
  1709. String *str_ptr;
  1710. Boolean *h_ptr,*s_ptr;
  1711. {
  1712.     XfwfMultiListItem *item;
  1713.  
  1714.     if (item_index < 0 || item_index >= MultiListNumItems(mlw))
  1715.         return(False);
  1716.     item = MultiListNthItem(mlw,item_index);
  1717.     *str_ptr = MultiListItemString(item);
  1718.     *h_ptr = MultiListItemHighlighted(item);
  1719.     *s_ptr = MultiListItemSensitive(item);
  1720.     return(True);
  1721. } /* End XfwfMultiListGetItemInfo */
  1722.  
  1723.  
  1724. /*---------------------------------------------------------------------------*
  1725.  
  1726.     XfwfMultiListSetNewData(mlw,list,nitems,longest,resize,
  1727.         sensitivity_array)
  1728.  
  1729.     This routine will set a new set of strings <list> into the
  1730.     MultiList widget <mlw>.  If <resize> is True, the MultiList widget will
  1731.     try to resize itself.
  1732.  
  1733.  *---------------------------------------------------------------------------*/
  1734.  
  1735. #if NeedFunctionPrototypes
  1736. void
  1737. XfwfMultiListSetNewData(XfwfMultiListWidget mlw, String *list,
  1738.             int nitems, int longest, Boolean resize,
  1739.             Boolean *sensitivity_array)
  1740. #else
  1741. void
  1742. XfwfMultiListSetNewData(mlw,list,nitems,longest,resize,sensitivity_array)
  1743. XfwfMultiListWidget mlw;
  1744. String *list;
  1745. int nitems,longest;
  1746. Boolean resize;
  1747. Boolean *sensitivity_array;
  1748. #endif
  1749. {
  1750.     DestroyOldData(mlw);
  1751.     MultiListList(mlw) = list;
  1752.     MultiListNumItems(mlw) = max(nitems,0);
  1753.     MultiListLongest(mlw) = max(longest,0);
  1754.     MultiListSensitiveArray(mlw) = sensitivity_array;
  1755.     InitializeNewData(mlw);
  1756.     RecalcCoords(mlw,resize,resize);
  1757.     if (XtIsRealized((Widget)mlw)) Redisplay(mlw,NULL,NULL);
  1758. } /* End XfwfMultiListSetNewData */
  1759.  
  1760.  
  1761.